# -*- coding: utf-8 -*-
import sqlite3
from sqlite3 import Error
import csv
import os
import re
import sys
from openpyxl import load_workbook, Workbook
from datetime import datetime, timedelta


def normalize_date(date_input):
    """
    将各种日期格式统一为"几月几日"格式
    
    参数:
        date_input: 原始日期值，可以是字符串、数字或None
    
    返回:
        统一格式后的日期字符串，无法解析时返回空字符串
    """
    if not date_input:
        return ""
    
    # 处理Excel序列号格式（数字或数字字符串）
    if isinstance(date_input, (int, float)):
        try:
            # Excel的日期序列号从1899-12-30开始
            excel_epoch = datetime(1899, 12, 30)
            dt = excel_epoch + timedelta(days=int(date_input))
            return f"{dt.month}月{dt.day}日"
        except (ValueError, OverflowError):
            pass  # 继续尝试其他格式
    
    # 处理字符串格式
    date_str = str(date_input).strip()
    if not date_str:
        return ""
    
    # 检查是否为数字字符串（Excel序列号）
    if date_str.isdigit():
        try:
            serial_num = int(date_str)
            excel_epoch = datetime(1899, 12, 30)
            dt = excel_epoch + timedelta(days=serial_num)
            return f"{dt.month}月{dt.day}日"
        except (ValueError, OverflowError):
            pass  # 继续尝试其他格式
    
    # 处理已格式化的中文日期
    if '月' in date_str and '日' in date_str:
        # 检查是否已经是正确的格式
        try:
            month = int(date_str.split('月')[0])
            day = int(date_str.split('月')[1].split('日')[0])
            if 1 <= month <= 12 and 1 <= day <= 31:
                return date_str  # 已经是正确格式
        except (ValueError, IndexError):
            pass
    
    # 定义可能的日期格式
    date_formats = [
        '%Y-%m-%d',
        '%Y/%m/%d',
        '%Y.%m.%d',
        '%m-%d',
        '%m/%d',
        '%Y年%m月%d日',
        '%m月%d日',
        '%m.%d',
        '%m-%d-%Y',
        '%m/%d/%Y'
    ]
    
    # 尝试解析日期
    for fmt in date_formats:
        try:
            dt = datetime.strptime(date_str, fmt)
            return f"{dt.month}月{dt.day}日"
        except ValueError:
            continue
    
    # 如果无法解析，返回空字符串
    return ""

def init_data_base(db_file="new_database.db"):
    """
    初始化数据库，创建必要的表结构
    
    参数:
        db_file: 数据库文件路径
    """
    conn = None
    try:
        conn = sqlite3.connect(db_file)
        cursor = conn.cursor()
        print("数据库文件 '{}' 已准备就绪（自动创建）".format(db_file))

        # 创建原始数据表
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS raw_comments (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                商品留言 TEXT NOT NULL
            )
        """)
        
        # 清空原始数据表
        cursor.execute("DELETE FROM raw_comments")
        
        # 创建提取结果表
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS extracted_info (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                姓名 TEXT,
                电话 TEXT,
                身份证号 TEXT,
                使用日期 TEXT,
                同行人信息 TEXT,
                comment_id INTEGER,
                FOREIGN KEY (comment_id) REFERENCES raw_comments(id)
            )
        """)
        
        # 清空提取结果表
        cursor.execute("DELETE FROM extracted_info")
        
        conn.commit()
        print("已成功初始化数据库表结构")

    except Error as e:
        print("错误: {}".format(e))
        if conn:
            conn.rollback()
    finally:
        if conn:
            conn.close()

def run_sql_script(sql_file, db_file="new_database.db"):
    """
    执行SQL文件，自动创建不存在的数据库文件
    
    参数:
        sql_file: SQL脚本文件路径
        db_file: 数据库文件路径（默认自动创建new_database.db）
    """
    conn = None
    try:
        # 连接数据库，如果文件不存在则自动创建
        conn = sqlite3.connect(db_file)
        cursor = conn.cursor()
        print("数据库文件 '{}' 已准备就绪（自动创建）".format(db_file))

        # 读取并执行SQL脚本
        with open(sql_file, 'r', encoding='utf-8') as f:
            sql_script = f.read()
        
        cursor.executescript(sql_script)
        conn.commit()
        print("已成功执行SQL脚本到 '{}'".format(db_file))

    except Error as e:
        print("错误: {}".format(e))
        if conn:
            conn.rollback()
    finally:
        if conn:
            conn.close()

def import_csv_data(csv_file, db_file="new_database.db"):
    """
    从CSV文件导入数据到raw_comments表
    
    参数:
        csv_file: CSV文件路径
        db_file: 数据库文件路径
    
    返回:
        tuple: (rows_inserted, product_name)
    """
    import sys
    conn = None
    product_name = None
    try:
        conn = sqlite3.connect(db_file)
        cursor = conn.cursor()
        
        # 读取CSV文件并提取商品名称
        with open(csv_file, 'r', encoding='utf-8') as f:
            reader = csv.DictReader(f)
            rows = list(reader)
            
            # 提取商品名称关键词
            if rows and len(rows) >= 2 and '商品名称' in rows[1]:
                product_name_str = str(rows[1]['商品名称']).strip()
                if '耀雪' in product_name_str:
                    product_name = '耀雪'
                elif '太仓' in product_name_str:
                    product_name = '太仓'
                else:
                    print(f"错误：商品名称 '{product_name_str}' 中未找到'耀雪'或'太仓'关键词")
                    sys.exit(1)
            else:
                print("错误：无法从CSV文件中提取商品名称")
                sys.exit(1)
        
        # 重新打开文件进行数据导入
        with open(csv_file, 'r', encoding='utf-8') as f:
            reader = csv.DictReader(f)
            rows_inserted = 0
            for row in reader:
                # 补充两项并列判断条件：商品数量=1，订单状态为待发货或已关闭
                if ('商品留言' in row and row['商品留言'].strip() and
                    '商品数量' in row and ((product_name == '太仓' and str(row['商品数量']).strip() in ['1', '2']) or (product_name != '太仓' and str(row['商品数量']).strip() == '1')) and
                    '订单状态' in row and str(row['订单状态']).strip() in ['待发货', '已关闭']):
                    cursor.execute("INSERT INTO raw_comments (商品留言) VALUES (?)", 
                                 (row['商品留言'],))
                    rows_inserted += 1
        
        conn.commit()
        print("成功从 '{}' 导入 {} 条记录".format(csv_file, rows_inserted))
        return rows_inserted, product_name
        
    except Error as e:
        print("导入错误: {}".format(e))
        if conn:
            conn.rollback()
        return 0, None
    finally:
        if conn:
            conn.close()

def process_data(db_file="new_database.db", product_name="太仓"):
    """
    执行数据处理，从raw_comments提取信息到extracted_info
    
    参数:
        db_file: 数据库文件路径
        product_name: 商品名称关键词（"太仓"或"耀雪"）
    """
    conn = None
    try:
        conn = sqlite3.connect(db_file)
        cursor = conn.cursor()
        
        # 清空提取结果表（避免重复数据）
        cursor.execute("DELETE FROM extracted_info")
        
        # 根据product_name选择不同的同行人信息提取字段
        if product_name == "太仓":
            companion_field = "拍多份的备注他人信息"
        elif product_name == "耀雪":
            companion_field = "同行人姓名+身份证"
        else:
            companion_field = "拍多份的备注他人信息"  # 默认
        
        # 构建动态SQL查询
        sql_query = f"""
            INSERT INTO extracted_info (姓名, 电话, 身份证号, 使用日期, 同行人信息, comment_id)
            SELECT
                -- 提取姓名
                TRIM(SUBSTR(商品留言, 
                       INSTR(商品留言, '姓名:') + 3,
                       CASE 
                           WHEN INSTR(商品留言, ';') > INSTR(商品留言, '姓名:') 
                           THEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '姓名:') + 3), ';') - 1
                           ELSE LENGTH(商品留言) - (INSTR(商品留言, '姓名:') + 3) + 1
                       END
                      )) AS 姓名,
                
                -- 提取电话
                TRIM(SUBSTR(商品留言,
                       INSTR(商品留言, '电话:') + 3,
                       CASE
                           WHEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '电话:') + 3), ';') > 0
                           THEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '电话:') + 3), ';') - 1
                           ELSE LENGTH(商品留言) - (INSTR(商品留言, '电话:') + 3) + 1
                       END
                      )) AS 电话,
                
                -- 提取身份证号
                TRIM(SUBSTR(商品留言,
                       INSTR(商品留言, '身份证号:') + 5,
                       CASE
                           WHEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '身份证号:') + 5), ';') > 0
                           THEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '身份证号:') + 5), ';') - 1
                           ELSE LENGTH(商品留言) - (INSTR(商品留言, '身份证号:') + 5) + 1
                       END
                      )) AS 身份证号,
                
                -- 提取使用日期
                TRIM(SUBSTR(商品留言,
                       INSTR(商品留言, '使用日期:') + 5,
                       CASE
                           WHEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '使用日期:') + 5), ';') > 0
                           THEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '使用日期:') + 5), ';') - 1
                           ELSE LENGTH(商品留言) - (INSTR(商品留言, '使用日期:') + 5) + 1
                       END
                      )) AS 使用日期,
                
                -- 提取同行人信息（动态字段）
                TRIM(SUBSTR(商品留言,
                    INSTR(商品留言, '{companion_field}:') + {len(companion_field) + 1},
                    CASE
                        WHEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '{companion_field}:') + {len(companion_field) + 1}), ';') > 0
                        THEN INSTR(SUBSTR(商品留言, INSTR(商品留言, '{companion_field}:') + {len(companion_field) + 1}), ';') - 1
                        ELSE LENGTH(商品留言) - (INSTR(商品留言, '{companion_field}:') + {len(companion_field) + 1}) + 1
                    END
                    )) AS 同行人信息,
                      
                id AS comment_id
            FROM raw_comments
            WHERE 商品留言 LIKE '%姓名:%'
        """
        
        cursor.execute(sql_query)
        
        conn.commit()
        processed_rows = cursor.rowcount
        print("成功处理 {} 条记录".format(processed_rows))
        return processed_rows
        
    except Error as e:
        print("数据处理错误: {}".format(e))
        if conn:
            conn.rollback()
        return 0
    finally:
        if conn:
            conn.close()

def process_and_generate_excel(excel_file="太仓雪票统计.xlsx", output_file="result.xlsx", db_file="new_database.db"):
    """
    处理并生成Excel文件，包含增强的数据处理功能
    
    功能增强：
    1. 仅复制"姓名"和"身份证号"均不为空的原始数据行，并执行日期格式化
    2. 追加新数据后按日期分类，不同日期数据块间插入空行
    3. 优化重复记录处理：发现n行重复则全部删除n行
    4. 保留原始数据的边框格式
    5. 优化边界框格式：主记录与同行人作为一个整体，在姓名列添加"两行一列"边界框
    """
    try:
        from openpyxl.styles import Border, Side
        from openpyxl.utils import get_column_letter
        
        # 定义边界框样式
        name_border = Border(
            left=Side(style='thin'),
            right=Side(style='thin'),
            top=Side(style='thin'),
            bottom=Side(style='thin')
        )
        
        # 读取原始Excel文件
        original_wb = load_workbook(excel_file)
        original_ws = original_wb.active
        
        print(f"原始文件: {excel_file}")
        print(f"原始数据行数: {original_ws.max_row}")
        
        # 步骤1: 提取并预处理原始数据 - 仅复制姓名和身份证号均不为空的行
        print("开始预处理原始数据...")
        
        original_data = []
        for row_idx in range(1, original_ws.max_row + 1):
            row_data = []
            border_styles = {}  # 存储边框样式
            
            # 收集整行数据和边框样式
            for col_idx in range(1, min(original_ws.max_column + 1, 5)):  # 只取前4列
                cell = original_ws.cell(row=row_idx, column=col_idx)
                row_data.append(cell.value)
                
                # 存储边框样式
                border_styles[col_idx] = {
                    'left': cell.border.left.style if cell.border.left else None,
                    'right': cell.border.right.style if cell.border.right else None,
                    'top': cell.border.top.style if cell.border.top else None,
                    'bottom': cell.border.bottom.style if cell.border.bottom else None
                }
            
            # 确保有4列数据
            while len(row_data) < 4:
                row_data.append('')
            
            # 检查姓名是否不为空（姓名在第2列）
            if (row_data[1] is not None and str(row_data[1]).strip()):  # 姓名
                
                # 对日期进行格式化处理
                formatted_date = normalize_date(str(row_data[0]) if row_data[0] else '')
                
                original_data.append({
                    'date': formatted_date,
                    'name': str(row_data[1]),
                    'id_card': str(row_data[2]),
                    'phone': str(row_data[3]) if row_data[3] else '',
                    'source': 'original',
                    'border_styles': border_styles  # 保留原始边框样式
                })
        
        print(f"提取到有效原始数据: {len(original_data)} 行")
        
        # 步骤2: 获取数据库中的新数据
        conn = sqlite3.connect(db_file)
        cursor = conn.cursor()
        cursor.execute("""
            SELECT 姓名, 电话, 身份证号, 使用日期, 同行人信息 
            FROM extracted_info 
            ORDER BY id
        """)
        
        new_results = cursor.fetchall()
        conn.close()
        
        # 步骤3: 处理新数据
        print("开始处理新数据...")
        
        all_records = original_data.copy()  # 从原始数据开始
        
        # 处理新数据
        for row in new_results:
            name, phone, id_card, use_date, companion = row
            
            if not name or not use_date:
                continue
                
            formatted_date = normalize_date(use_date)
            if not formatted_date:
                continue
            
            # 处理同行人信息
            companions = []
            if companion and str(companion).strip():
                import re
                separators = r'[\n,;\s]+'
                companion_parts = re.split(separators, str(companion).strip())
                companion_parts = [part.strip() for part in companion_parts if part.strip()]
                
                for part in companion_parts:
                    companion_data = parse_companion_info(part)
                    if companion_data:
                        companions.append(companion_data)
                    else:
                        companions.append({
                            'name': part,
                            'id_card': '',
                            'phone': phone or ''
                        })
            
            # 添加主记录
            main_record = {
                'date': formatted_date,
                'name': str(name),
                'id_card': str(id_card or ''),
                'phone': str(phone or ''),
                'source': 'new',
                'is_main': True,
                'group_id': f"{formatted_date}_{name}_{id_card}",  # 用于分组
                'border_styles': None  # 新数据没有原始边框
            }
            all_records.append(main_record)
            
            # 添加同行人记录
            for companion in companions:
                companion_record = {
                    'date': formatted_date,
                    'name': companion['name'],
                    'id_card': companion['id_card'],
                    'phone': companion['phone'],
                    'source': 'new',
                    'is_main': False,
                    'group_id': main_record['group_id'],  # 关联到主记录
                    'border_styles': None  # 新数据没有原始边框
                }
                all_records.append(companion_record)
        
        print(f"合并后总记录数: {len(all_records)}")
        
        # 步骤4: 优化重复记录处理 - 发现n行重复则全部删除n行
        print("开始优化重复记录处理...")
        
        # 创建记录映射，跟踪重复记录
        record_map = {}
        duplicate_groups = {}
        
        for idx, record in enumerate(all_records):
            # 创建唯一标识符：日期|姓名|身份证|电话
            key = f"{record['date']}|{record['name']}|{record['id_card']}|{record['phone']}"
            
            if key not in record_map:
                record_map[key] = []
            record_map[key].append(idx)
        
        # 找出所有重复的记录组（n>=2的行）
        for key, indices in record_map.items():
            if len(indices) >= 2:  # 发现重复
                duplicate_groups[key] = indices
        
        # 收集所有需要删除的行索引
        rows_to_delete = set()
        for key, indices in duplicate_groups.items():
            print(f"发现重复记录: {key} - 共 {len(indices)} 行")
            rows_to_delete.update(indices)
        
        # 创建最终记录列表，排除所有重复的行
        final_records = []
        for idx, record in enumerate(all_records):
            if idx not in rows_to_delete:
                final_records.append(record)
        
        print(f"删除重复记录数: {len(rows_to_delete)}")
        print(f"最终记录数: {len(final_records)}")
        
        # 步骤5: 按日期分组并排序
        from collections import defaultdict
        date_groups = defaultdict(list)
        
        for record in final_records:
            date_groups[record['date']].append(record)
        
        # 按日期倒序排序
        def sort_date_key(date_str):
            """日期排序键"""
            try:
                if '月' in date_str and '日' in date_str:
                    month = int(date_str.split('月')[0])
                    day = int(date_str.split('月')[1].split('日')[0])
                    return (month, day)
                return (0, 0)
            except:
                return (0, 0)
        
        sorted_dates = sorted(date_groups.keys(), key=sort_date_key, reverse=True)
        
        # 步骤6: 创建新的Excel文件
        new_wb = Workbook()
        new_ws = new_wb.active
        new_ws.title = "雪票统计"
        
        # 写入数据
        current_row = 1
        
        for date_idx, date_str in enumerate(sorted_dates):
            # 不同日期之间插入空行（除了第一个日期）
            if date_idx > 0:
                current_row += 1
            
            # 按组ID分组，以便处理主记录和同行人的边界框
            group_records = defaultdict(list)
            for record in date_groups[date_str]:
                group_id = record.get('group_id', f"{record['date']}_{record['name']}_{record['id_card']}")
                group_records[group_id].append(record)
            
            # 对每个组进行处理
            for group_id, records in group_records.items():
                # 排序：主记录在前，同行人在后
                sorted_records = sorted(records, key=lambda x: (not x.get('is_main', False), x['name']))
                
                if not sorted_records:
                    continue
                
                start_row = current_row
                end_row = start_row + len(sorted_records) - 1
                
                # 检查这个组是否有同行人（即记录数>1）
                has_companions = len(sorted_records) > 1
                
                # 写入该组的所有记录
                for i, record in enumerate(sorted_records):
                    row_num = start_row + i
                    
                    # 写入数据
                    new_ws.cell(row=row_num, column=1, value=record['date'])
                    new_ws.cell(row=row_num, column=2, value=record['name'])
                    new_ws.cell(row=row_num, column=3, value=record['id_card'])
                    new_ws.cell(row=row_num, column=4, value=record['phone'])
                    
                    # 应用边框样式
                    for col_idx in range(1, 5):
                        cell = new_ws.cell(row=row_num, column=col_idx)
                        
                        # 如果是原始数据且有边框样式，则应用原始边框
                        if record['source'] == 'original' and record.get('border_styles'):
                            border_style = record['border_styles'].get(col_idx, {})
                            cell.border = Border(
                                left=Side(style=border_style.get('left')),
                                right=Side(style=border_style.get('right')),
                                top=Side(style=border_style.get('top')),
                                bottom=Side(style=border_style.get('bottom'))
                            )
                        # 如果是新数据且有同行人，只为姓名列添加整体边框
                        elif record['source'] == 'new' and has_companions and col_idx == 2:
                            # 只为有同行人的记录组添加边界框
                            # 第一行：上边框和左右边框
                            if i == 0:
                                cell.border = Border(
                                    left=Side(style='thin'),
                                    right=Side(style='thin'),
                                    top=Side(style='thin'),
                                    bottom=Side(style=None)
                                )
                            # 最后一行：下边框和左右边框
                            elif i == len(sorted_records) - 1:
                                cell.border = Border(
                                    left=Side(style='thin'),
                                    right=Side(style='thin'),
                                    top=Side(style=None),
                                    bottom=Side(style='thin')
                                )
                            # 中间行：仅左右边框
                            else:
                                cell.border = Border(
                                    left=Side(style='thin'),
                                    right=Side(style='thin'),
                                    top=Side(style=None),
                                    bottom=Side(style=None)
                                )
                        # 其他情况：新数据但无同行人，不添加边框
                        elif record['source'] == 'new':
                            # 新数据无同行人，不应用边框
                            cell.border = Border()  # 无边框
            
                current_row = end_row + 1
        
        # 调整列宽
        for col_idx in range(1, 5):
            column_letter = get_column_letter(col_idx)
            max_length = 0
            for row in new_ws.iter_rows(values_only=True):
                if row and len(row) >= col_idx and row[col_idx-1] is not None:
                    max_length = max(max_length, len(str(row[col_idx-1])))
            new_ws.column_dimensions[column_letter].width = min(max_length + 2, 50)
        
        # 保存文件
        new_wb.save(output_file)
        
        # 生成CSV文件
        import csv
        with open('result.csv', 'w', newline='', encoding='utf-8') as csvfile:
            writer = csv.writer(csvfile)
            writer.writerow(["姓名", "电话", "身份证号", "使用日期", "同行人信息"])
            
            for date_str in sorted_dates:
                for record in date_groups[date_str]:
                    writer.writerow([record['name'], record['phone'], record['id_card'], record['date'], ''])
        
        print(f"处理完成！总数据行数: {current_row - 1}")
        print(f"最终记录数: {len(final_records)}")
        
        return True
        
    except Exception as e:
        print(f"处理Excel文件时出错: {str(e)}")
        import traceback
        traceback.print_exc()
        return False

def parse_companion_info(text):
    """
    智能解析单个同行人信息，支持所有格式
    
    支持的格式：
    1. 标准格式：姓名、手机号、身份证号用空格分隔，顺序不限
    2. 紧密排列：姓名手机号身份证号无分隔符
    3. 特殊格式：包含描述性文字和各种分隔符
    4. 任意顺序：手机号、身份证号可以在姓名前面
    
    参数:
        text: 同行人信息文本
    
    返回:
        包含姓名、身份证、手机号的字典
    """
    if not text or not text.strip():
        return None
    
    text = text.strip()
    result = {'name': '', 'id_card': '', 'phone': ''}
    
    # 步骤1: 清理描述性文字和特殊符号
    # 更强大的清理规则，处理各种特殊字符和描述性文字
    clean_text = re.sub(r'(手机号|电话|手机|身份证|号码|姓名|名字|【|】|\(|\)|（|）|"|"|\'|\'|:|：|\s|_|,|，|、|;|；|—|-|_|\u3000)+', ' ', text, flags=re.IGNORECASE)
    clean_text = re.sub(r'\s+', ' ', clean_text)
    clean_text = clean_text.strip()
    
    if not clean_text:
        return None
    
    # 步骤2: 提取所有关键信息
    parts = clean_text.split()
    
    # 识别各个部分
    for part in parts:
        part = part.strip()
        if not part:
            continue
            
        # 识别18位身份证号
        if re.fullmatch(r'\d{17}[\dXx]', part):
            result['id_card'] = part
        # 识别11位手机号（以1开头）
        elif re.fullmatch(r'1[3-9]\d{9}', part):
            result['phone'] = part
        # 识别中文姓名（2-4个汉字）
        elif re.fullmatch(r'[\u4e00-\u9fa5]{2,4}', part):
            result['name'] = part
    
    # 步骤3: 处理紧密排列（无空格分隔）
    if not any([result['name'], result['id_card'], result['phone']]) and len(parts) == 1:
        # 尝试从紧密排列中提取
        # 模式：任意顺序的姓名+手机号+身份证号
        patterns = [
            # 姓名 + 手机号 + 身份证
            r'^([\u4e00-\u9fa5]{2,4})(1[3-9]\d{9})(\d{17}[\dXx])$',
            # 姓名 + 身份证 + 手机号
            r'^([\u4e00-\u9fa5]{2,4})(\d{17}[\dXx])(1[3-9]\d{9})$',
            # 手机号 + 姓名 + 身份证
            r'^(1[3-9]\d{9})([\u4e00-\u9fa5]{2,4})(\d{17}[\dXx])$',
            # 手机号 + 身份证 + 姓名
            r'^(1[3-9]\d{9})(\d{17}[\dXx])([\u4e00-\u9fa5]{2,4})$',
            # 身份证 + 姓名 + 手机号
            r'^(\d{17}[\dXx])([\u4e00-\u9fa5]{2,4})(1[3-9]\d{9})$',
            # 身份证 + 手机号 + 姓名
            r'^(\d{17}[\dXx])(1[3-9]\d{9})([\u4e00-\u9fa5]{2,4})$',
            # 只有姓名和身份证
            r'^([\u4e00-\u9fa5]{2,4})(\d{17}[\dXx])$',
            r'^(\d{17}[\dXx])([\u4e00-\u9fa5]{2,4})$',
            # 只有姓名和手机号
            r'^([\u4e00-\u9fa5]{2,4})(1[3-9]\d{9})$',
            r'^(1[3-9]\d{9})([\u4e00-\u9fa5]{2,4})$',
        ]
        
        for pattern in patterns:
            match = re.match(pattern, clean_text)
            if match:
                groups = match.groups()
                # 重新分配识别到的信息
                for group in groups:
                    if re.fullmatch(r'\d{17}[\dXx]', group):
                        result['id_card'] = group
                    elif re.fullmatch(r'1[3-9]\d{9}', group):
                        result['phone'] = group
                    elif re.fullmatch(r'[\u4e00-\u9fa5]{2,4}', group):
                        result['name'] = group
                break
    
    # 步骤4: 验证结果有效性
    has_valid_info = any([
        result['name'] and len(result['name']) >= 2,
        result['id_card'] and len(result['id_card']) == 18,
        result['phone'] and len(result['phone']) == 11
    ])
    
    return result if has_valid_info else None

def export_to_csv(output_file="result.csv", db_file="new_database.db"):
    """
    将提取的所有表信息导出到CSV文件
    
    参数:
        output_file: 输出CSV文件名，默认为result.csv
        db_file: 数据库文件路径
    """
    try:
        conn = sqlite3.connect(db_file)
        cursor = conn.cursor()
        
        # 查询提取的所有数据
        cursor.execute("""
            SELECT 姓名, 电话, 身份证号, 使用日期, 同行人信息 
            FROM extracted_info 
            ORDER BY id
        """)
        
        results = cursor.fetchall()
        
        if not results:
            print("没有找到可导出的数据")
            return False
        
        # 写入CSV文件
        with open(output_file, 'w', encoding='utf-8', newline='') as csvfile:
            writer = csv.writer(csvfile)
            
            # 写入表头
            writer.writerow(['姓名', '电话', '身份证号', '使用日期', '同行人信息'])
            
            # 写入数据
            for row in results:
                writer.writerow(row)
        
        print("成功导出 {} 条记录到 '{}'".format(len(results), output_file))
        
        # 显示导出内容预览
        print("\n=== 导出内容预览 ===")
        with open(output_file, 'r', encoding='utf-8') as f:
            lines = f.readlines()
            for line in lines[:6]:  # 显示前6行（1行表头+5行数据）
                print(line.strip())
        
        return True
        
    except Exception as e:
        print("导出错误: {}".format(e))
        return False
    finally:
        if conn:
            conn.close()

if __name__ == '__main__':
    # 执行完整流程：从data.csv读取数据 -> 使用process_data.sql处理 -> 导出到result.csv
    print("=== 开始执行数据提取流程 ===")
    
    # 1. 删除旧数据库文件（如果存在）
    if os.path.exists("new_database.db"):
        os.remove("new_database.db")
        print("已删除旧数据库文件")
    
    # 2. 初始化数据库，创建表结构并清空表
    init_data_base()
    
    # 3. 导入CSV数据 - 从桌面目录获取CSV文件
    import glob
    desktop_path = os.path.expanduser("~/Desktop")
    csv_files = glob.glob(os.path.join(desktop_path, "*.csv"))
    csv_files = [f for f in csv_files if f.startswith(os.path.join(desktop_path, "Goods_youzan"))]
    
    if not csv_files:
        # 检查桌面是否有data.csv
        default_csv = os.path.join(desktop_path, "data.csv")
        if os.path.exists(default_csv):
            latest_csv = default_csv
            print("使用桌面目录的data.csv")
        else:
            print("警告：未找到CSV文件，请确保CSV文件在桌面目录")
            latest_csv = default_csv
    else:
        # 按创建时间排序，获取最新的文件
        csv_files.sort(key=lambda x: os.path.getctime(x), reverse=True)
        latest_csv = csv_files[0]
        print(f"使用最新的CSV文件: {os.path.basename(latest_csv)}")
    
    # 4. 导入数据并获取商品名称
    rows, product_name = import_csv_data(latest_csv)
    if rows == 0:
        print("没有数据被导入")
    else:
        print(f"成功导入 {rows} 条记录，商品类型: {product_name}")
    
    # 5. 处理数据，根据商品名称选择不同的同行人信息提取逻辑
    processed_rows = process_data(product_name=product_name)
    print(f"处理了 {processed_rows} 条记录")
    
    # 6. 生成Excel文件
    desktop_path = os.path.expanduser("~/Desktop")
    if product_name == "太仓":
        excel_file = os.path.join(desktop_path, "太仓雪票统计.xlsx")
    elif product_name == "耀雪":
        excel_file = os.path.join(desktop_path, "耀雪雪票统计.xlsx")
    else:
        excel_file = os.path.join(desktop_path, "太仓雪票统计.xlsx")
    
    output_file = os.path.join(desktop_path, "result.xlsx")
    success = process_and_generate_excel(excel_file=excel_file, output_file=output_file)
    if success:
        print("Excel文件生成成功")
    
    # 7. 导出到CSV
    #
    
    print("=== 数据提取流程完成 ===")
    